﻿//系统业务辅助类
(
function ()
{
    //启用严格模式
    'use strict';

    //获得全局对象
    var _spms = window.spms;

    //判断是否已经创建
    if ( typeof _spms == 'undefined' )
    {
        //初始化全局对象
        _spms = {};

        //应用到全局对象
        window.spms = _spms;
    }

    //添加常量定义
    _spms.constant =
    {
        //错误码
        ErrorCodes:
        {
            //未知错误
            Error_Unknown: 515,
            //未认证
            Error_Unauthenticated: 516,
            //未授权
            Error_Unauthorized: 518,
            //常规错误
            Error_Application: 520
        },
        HttpMethod:
        {
            Get: 'GET',
            POST: 'POST'
        }
    };

    //添加辅助类
    _spms.common =
    {
        //获得树节点的复选框
        GetTreeNodeCheckBox: function ( node )
        {
            //判断是否有效
            if ( !spms.common.IsValid( node ) )
            {
                //返回空引用
                return null;
            }

            //获得树对象
            var tree = node.getOwnerTree();

            //判断是否有效
            if ( !spms.common.IsValid( tree ) )
            {
                //返回空引用
                return null;
            }

            //获得视图对象
            var view = tree.getView();

            //判断是否有效
            if ( !spms.common.IsValid( view ) )
            {
                //返回空引用
                return null;
            }

            //获得节点元素
            var htmlElement = view.getNode( node, true );

            //判断是否有效
            if ( !spms.common.IsValid( htmlElement ) )
            {
                //返回空引用
                return null;
            }

            //检索复选框
            var result = Ext.query( 'input:first-of-type[role=checkbox]', htmlElement, 'select', true );

            //判断是否选中元素
            if ( result.length > 0 )
            {
                //返回第一个元素
                return result[0];
            }

            //返回空引用
            return null;
        },
        //获得树节点的复选框
        GetTreeNodeHtmlElement: function ( node )
        {
            //判断是否有效
            if ( !spms.common.IsValid( node ) )
            {
                //返回空引用
                return null;
            }

            //获得树对象
            var tree = node.getOwnerTree();

            //判断是否有效
            if ( !spms.common.IsValid( tree ) )
            {
                //返回空引用
                return null;
            }

            //获得视图对象
            var view = tree.getView();

            //判断是否有效
            if ( !spms.common.IsValid( view ) )
            {
                //返回空引用
                return null;
            }

            //获得节点元素
            return view.getNode( node, true );
        },
        //将指定的字符串转换为拼音
        ConvertToPinYin: function ( source, dest )
        {
            //判断是否需要发送请求
            if ( spms.common.IsNullOrEmpty( source ) || !spms.common.IsValid( dest ) )
            {
                return;
            }

            //创建请求对象
            Ext.Ajax.request
            (
                {
                    url: spms.url.Action( "ConvertToPinYin", "Common" ),
                    params: { source: source },
                    method: spms.constant.HttpMethod.Get,
                    callback: function ( options, success, response )
                    {
                        //判定是否发生错误
                        if ( !success )
                        {
                            //直接返回
                            return;
                        }

                        //判定是否有反馈对象
                        if ( !response )
                        {
                            //直接返回
                            return;
                        }

                        //用于保存反馈对象
                        var responseData = {};

                        //解析反馈对象
                        try
                        {
                            //解析反馈数据
                            responseData = Ext.JSON.decode( response.responseText, true );
                        }
                        catch ( error )
                        {
                            //输出日志
                            console.log( '转换拼音的过程中发生错误' + error )

                            //直接返回
                            return;
                        }

                        //判定是否称成功
                        if ( responseData.success )
                        {
                            //返回结果
                            dest.setValue( responseData.data );
                        }
                    }
                }
            );
        },
        //执行Ajax请求
        DoAjaxRequest: function ( options )
        {
            //判断是否指定了参数
            if ( !spms.common.IsValid( options ) )
            {
                //如果没有指定，则直接返回
                return;
            }

            //判断是否显示Mask
            if ( spms.common.IsValid( options.maskTarget ) )
            {
                //显示加载
                options.maskTarget.setLoading( options.mask );
            }

            //创建请求对象
            Ext.Ajax.request
            (
                {
                    url: options.url,
                    method: spms.constant.HttpMethod.POST,
                    jsonData: options.params,
                    callback: function ( ajaxOptions, success, response )
                    {
                        //判断是否显示Mask
                        if ( spms.common.IsValid( options.maskTarget ) )
                        {
                            //隐藏加载
                            options.maskTarget.setLoading( false );
                        }

                        //处理错误
                        if ( spms.exception.HandleAjaxRequestError( ajaxOptions, success, response ) )
                        {
                            //判断是否指定回调
                            if ( spms.common.IsValid( options.callback ) && jQuery.isFunction( options.callback ) )
                            {
                                //执行回调
                                options.callback( options );
                            }
                        }
                    }
                }
            );
        },
        //执行Ajax请求
        DoAjaxRequestWithConfirm: function ( options )
        {
            //判断是否指定了参数
            if ( !spms.common.IsValid( options ) )
            {
                //如果没有指定，则直接返回
                return;
            }

            //询问
            Ext.Msg.show
            (
                {
                    title: spms.resources.text_app_title,
                    msg: options.msg,
                    buttons: Ext.Msg.YESNO,
                    icon: Ext.Msg.QUESTION,
                    autoScroll: true,
                    closeAction: 'destroy',
                    fn: function ( button, text, eOpts )
                    {
                        //判断是否确定删除 
                        if ( button == 'yes' )
                        {
                            //执行请求
                            spms.common.DoAjaxRequest( options );
                        }
                    }
                }
            );
        },
        //生成新的GUID
        NewGuid: function ()
        {
            //用于保存生成的GUID
            var guid = '';

            //循环生成GUID的每一位数字
            for ( var i = 1; i <= 32; i++ )
            {
                //生成随机数
                var n = Math.floor( Math.random() * 16.0 ).toString( 16 );

                //添加数字
                guid += n;

                //添加分割符
                if ( ( i == 8 ) || ( i == 12 ) || ( i == 16 ) || ( i == 20 ) )
                {
                    guid += "-";
                }
            }

            //返回生成的GUID
            return guid;
        },
        //判断字符串是否为空或者空字符
        IsNullOrEmpty: function ( obj )
        {
            //判断对象是否有效
            if ( !spms.common.IsValid( obj ) )
            {
                //认为为空字符串
                return true;
            }

            //转换为字符串
            var value = obj.toString();

            //返回结果
            return value.length == 0;
        },
        //判断对象是否有效
        IsValid: function ( obj )
        {
            //判断是否有效
            return ( typeof obj == 'undefined' || null == obj ) ? false : true;
        },
        //重置表单内容
        ResetForm: function ( sender )
        {
            //判断是否有效
            if ( sender )
            {
                //检索到指定的窗体
                var form = $( sender ).closest( 'form' );

                //判断窗体是否有效
                if ( form )
                {
                    //重置窗体
                    form[0].reset();
                }
            }
        },
        //设置组件的可用状态
        SetEnabled: function ( itemID, isEnabled )
        {
            //判断是否指定了元素编号
            if ( itemID )
            {
                //获得组件
                var component = Ext.getCmp( itemID );

                //判断组件是否是否存在
                if ( component )
                {
                    //禁用组件
                    component.setDisabled( !isEnabled );
                }
            }
        },
        //设置组件的禁用状态
        SetDisabled: function ( itemID, isDisabled )
        {
            //判断是否指定了元素编号
            if ( itemID )
            {
                //获得组件
                var component = Ext.getCmp( itemID );

                //判断组件是否是否存在
                if ( component )
                {
                    //禁用组件
                    component.setDisabled( isDisabled );
                }
            }
        },
        //应用特性
        Apply: function ( itemID, options )
        {
            //判断是否指定了元素编号
            if ( itemID && options )
            {
                //获得组件
                var component = Ext.getCmp( itemID );

                //判断组件是否是否存在
                if ( component )
                {
                    //应用特性
                    Ext.apply( component, options );
                }
            }
        },
        //应用特性
        ApplyIIf: function ( itemID, condition, trueOptions, falseOptions )
        {
            //判断是否指定了元素编号
            if ( itemID && trueOptions && falseOptions )
            {
                //获得组件
                var component = Ext.getCmp( itemID );

                //判断组件是否是否存在
                if ( component )
                {
                    //应用特性
                    if ( condition )
                    {

                        for ( var property in trueOptions )
                        {
                            //获得方法名称
                            var methodName = 'set'.concat( property.substring( 0, 1 ).toUpperCase(), property.substring( 1 ) );

                            //调用方法
                            eval( 'component.'.concat( methodName, '(trueOptions[property])' ) );
                        }
                    }
                    else
                    {
                        for ( var property in falseOptions )
                        {
                            //获得方法名称
                            var methodName = 'set'.concat( property.substring( 0, 1 ).toUpperCase(), property.substring( 1 ) );

                            //调用方法
                            eval( 'component.'.concat( methodName, '(falseOptions[property])' ) );
                        }
                    }
                }
            }
        },
        //获得第一条选中的记录
        GetFirstSelectedRecord: function ( grid )
        {
            //判断是否有效
            if ( grid )
            {
                //获得选择模型
                var selectionModel = grid.getSelectionModel();

                //判断选择模型是否有效
                if ( selectionModel )
                {
                    //获得选中记录
                    var selection = selectionModel.getSelection();

                    //判断是否选中记录 
                    if ( selection.length > 0 )
                    {
                        return selection[0];
                    }
                }
            }

            //返回空引用
            return null;
        },
        //预览图片
        Preview: function ( options )
        {
            //判断是否指定了参数
            if ( !spms.common.IsValid( options ) )
            {
                return;
            }

            //定义当前对象
            var me = spms.common;

            //判断登录窗是否已经创建
            if ( typeof me._WinLogin == 'undefined' )
            {
                //创建窗体隐藏函数
                me._WinPreview_HideFn = function ()
                {
                    //隐藏窗体
                    me._WinPreview.hide();

                    //移除事件监听
                    this.removeListener( 'click', me._WinPreview_HideFn, this );
                }

                //创建检索窗体
                me._WinPreview = Ext.create
                (
                    'Ext.window.Window',
                    {
                        title: '图片预览',
                        method: spms.constant.HttpMethod.POST,
                        waitMsgTarget: true,
                        waitTitle: spms.resources.text_app_title,
                        iconCls: 'spms-icon-image',
                        cls: 'spms-window',
                        closeAction: 'hide',
                        draggable: true,
                        ghost: false,
                        maximizable: false,
                        maximized: false,
                        autoScroll: true,
                        bodyBorder: false,
                        isTopContainer: true,
                        modal: true,
                        resizable: true,
                        bodyPadding: 0,
                        layout: 'fit',
                        listeners:
                        {
                            //挂接显示事件
                            show: function ( win, eOpts )
                            {
                                //检索Mask
                                var mask = Ext.select( '.x-mask' );

                                //判断是否选中
                                if ( spms.common.IsValid( mask ) )
                                {
                                    //挂接事件
                                    mask.on( 'click', me._WinPreview_HideFn, mask );
                                }
                            }
                        },
                        items:
                        [
                            {
                                xtype: 'panel',
                                border: false,
                                autoScroll: true,
                                bodyCls: 'spms-image-preview',
                                minWidth: 482,
                                minHeight: 482,
                                items:
                                [
                                    {
                                        xtype: 'image',
                                        itemId: 'ImagePreview'
                                    }
                                ]
                            }
                        ]
                    }
                );
            }

            //获得组件
            var preview = me._WinPreview.down( '#ImagePreview' );

            //判断组件是否存在
            if ( spms.common.IsValid( preview ) )
            {
                //判断是否指定了图片地址
                if ( spms.common.IsValid( options.url ) )
                {
                    preview.setSrc( options.url );
                }
                else
                {
                    preview.setSrc( Ext.BLANK_IMAGE_URL );
                }
            }

            //判断是否设定了宽度
            if ( spms.common.IsValid( options.width ) )
            {
                //设置宽度
                me._WinPreview.setWidth( options.width );
            }
            else
            {
                //设置宽度
                me._WinPreview.setWidth( 540 );
            }

            //判断是否设定了高度
            if ( spms.common.IsValid( options.height ) )
            {
                //设置高度
                me._WinPreview.setHeight( options.height );
            }
            else
            {
                //设置高度
                me._WinPreview.setHeight( 540 );
            }

            //判断是否需要设置标题
            if ( spms.common.IsValid( options.title ) )
            {
                //设置标题
                me._WinPreview.setTitle( options.title );
            }

            //居中
            me._WinPreview.center();
            //显示检索窗
            me._WinPreview.show();
        },
        //执行登录
        Login: function ()
        {
            //定义当前对象
            var me = spms.common;

            //判断登录窗是否已经创建
            if ( typeof me._WinLogin == 'undefined' )
            {
                //创建检索窗体
                me._WinLogin = Ext.create
                (
                    'Ext.window.Window',
                    {
                        title: '用户登录',
                        method: spms.constant.HttpMethod.POST,
                        waitMsgTarget: true,
                        waitTitle: spms.resources.text_app_title,
                        iconCls: 'spms-icon-login',
                        cls: 'spms-window',
                        closeAction: 'hide',
                        draggable: true,
                        ghost: false,
                        maximizable: false,
                        maximized: false,
                        width: 480,
                        height: 200,
                        autoScroll: false,
                        bodyBorder: false,
                        isTopContainer: true,
                        modal: true,
                        resizable: false,
                        bodyPadding: 0,
                        layout: 'fit',
                        dockedItems:
                        [
                            {
                                xtype: 'toolbar',
                                dock: 'bottom',
                                ui: 'footer',
                                cls: 'spms-window-toolbar',
                                padding: '9 0 9 0',
                                items:
                                [
                                    '->'
                                    ,
                                    {
                                        text: '确定',
                                        xtype: 'button',
                                        cls: 'spms-window-toolbar-button',
                                        handler: function ()
                                        {
                                            //获得表单
                                            var form = spms.common._WinLogin.down( 'form' );

                                            //获得表单对象
                                            var formBase = form.getForm();

                                            //检查数据是否合法
                                            if ( formBase.isValid() )
                                            {
                                                //提交数据
                                                formBase.submit
                                                (
                                                    {
                                                        url: spms.url.Action( 'AjaxLogin', 'Account' ),
                                                        method: spms.constant.HttpMethod.Post,
                                                        submitEmptyText: false,
                                                        waitTitle: spms.resources.text_submitting_title,
                                                        waitMsg: spms.resources.text_submitting,
                                                        success: function ( form, action )
                                                        {
                                                            //处理提交错误
                                                            if ( spms.exception.HandleSuccessError( form, action ) )
                                                            {
                                                                //重置数据
                                                                formBase.reset();

                                                                //隐藏窗体
                                                                spms.common._WinLogin.hide();
                                                            }
                                                        },
                                                        failure: spms.exception.HandleFailureError
                                                    }
                                                );
                                            }
                                        }
                                    },
                                    {
                                        text: '取消',
                                        xtype: 'button',
                                        cls: 'spms-window-toolbar-button',
                                        handler: function ()
                                        {
                                            //隐藏窗体
                                            spms.common._WinLogin.hide();
                                        }
                                    }
                                ]
                            }
                        ],
                        listeners:
                        {
                            //挂接显示事件
                            show: function ( win, options )
                            {
                                //获得表单
                                var form = win.down( 'form' );

                                //判断是否存在
                                if ( form )
                                {
                                    //获得窗体
                                    form.getForm().reset();

                                    //设置焦点
                                    form.down( 'field' ).focus( false, 50 );
                                }
                            }
                        },
                        items:
                        [
                            {
                                xtype: 'form',
                                frame: false,
                                waitMsgTarget: true,
                                waitTitle: spms.resources.text_app_title,
                                bodyPadding: 12,
                                bodyCls: 'spms-window-form-body',
                                bodyBorder: false,
                                border: false,
                                defaultType: 'textfield',
                                fieldDefaults:
                                {
                                    labelAlign: 'left',
                                    labelWidth: 72,
                                    anchor: '100%',
                                    msgTarget: 'qtip'
                                },
                                items:
                                [
                                    {
                                        xtype: 'textfield',
                                        name: 'LoginName',
                                        maxLength: 40,
                                        fieldLabel: '用户名',
                                        emptyText: '用户名',
                                        allowBlank: false,
                                        disabled: false
                                    },
                                    {
                                        xtype: 'textfield',
                                        inputType: 'password',
                                        name: 'Password',
                                        maxLength: 40,
                                        fieldLabel: '密码',
                                        emptyText: '登录密码',
                                        allowBlank: false,
                                        disabled: false
                                    },
                                    {
                                        xtype: 'checkboxfield',
                                        name: 'RememberMe',
                                        inputValue: 'true',
                                        checked: false,
                                        boxLabel: spms.resources.text_rememberme,
                                        boxLabelCls: 'spms-window-checkbox-boxlabel',
                                        cls: 'spms-window-checkbox'
                                    }
                                ]
                            }
                        ]
                    }
                );
            }

            //居中
            me._WinLogin.center();
            //显示检索窗
            me._WinLogin.show();
        },
        //判断Flash插件是否已经安装
        IsFlashInstalled: function ()
        {
            //获得当前对象
            var me = this;

            //判断是否已经做过检测
            if ( me._IsFlashInstalled )
            {
                //如果已经安装，则不需要检测
                return me._IsFlashInstalled;
            }

            try
            {
                //判断是否为非IE浏览器
                if ( navigator.mimeTypes.length > 0 )
                {
                    //尝试创建
                    me._IsFlashInstalled = navigator.mimeTypes["application/x-shockwave-flash"].enabledPlugin != null;
                }
                    //判断是否为IE浏览器
                else if ( window.ActiveXObject )
                {
                    //尝试创建对象
                    new ActiveXObject( "ShockwaveFlash.ShockwaveFlash" );

                    //设置已经安装
                    me._IsFlashInstalled = true;
                }
                else
                {
                    //无法检查，则默认为没有安装
                    me._IsFlashInstalled = false;
                }
            }
            catch ( e )
            {
                //如果发生异常，则认为没有安装
                me._IsFlashInstalled = false;
            }

            //返回安装状态
            return me._IsFlashInstalled;
        },
        //获得表格的插件
        GetGridPlugin: function ( grid, pluginID )
        {
            //判断是否指定参数
            if ( !spms.common.IsValid( grid ) || !spms.common.IsValid( pluginID ) )
            {
                return null;
            }

            //判断是否为可锁定表格
            if ( spms.common.IsValid( grid.normalGrid ) )
            {
                return grid.normalGrid.getPlugin( pluginID );
            }
            else
            {
                return grid.getPlugin( pluginID );
            }
        },
        //上传文件
        UploadFile: function ( options )
        {
            //获得当前对象
            var me = this;

            //是否使用Flash上传
            var isUseFlash = true;

            //判断是否指定了上传模式
            if ( !spms.common.IsValid( me._UploadMode ) )
            {
                //设置为使用Flash上传
                me._UploadMode = 'Flash';
            }

            //判定Flash插件是否安装
            if ( !spms.common.IsFlashInstalled() )
            {
                //判断是否需要显示提示对话框
                if ( me._UploadMode != 'HTML' )
                {
                    //提示信息
                    Ext.MessageBox.show
                    (
                        {
                            title: spms.resources.text_upload_error_title,
                            msg: spms.resources.text_flash_prompt,
                            buttons: Ext.Msg.YESNO,
                            icon: Ext.Msg.QUESTION,
                            autoScroll: true,
                            closeAction: 'destroy',
                            fn: function ( buttonId, text, opt )
                            {
                                //判断是否安装
                                if ( buttonId == 'yes' )
                                {
                                    //打开Flash的安装地址
                                    window.open( spms.resources.text_url_flash );

                                    //直接返回
                                    return;
                                }
                                else
                                {
                                    //设置使用传统方式上传
                                    me._UploadMode = 'HTML';

                                    //使用传统方式上传
                                    me._UploadFileCore.call( me, options );
                                }
                            }
                        }
                    );
                }
                else
                {
                    //使用传统方式上传
                    me._UploadFileCore.call( me, options );
                }
            }
            else
            {
                //使用Flash方式上传
                me._UploadFileCore_ByFlash.call( me, options );
            }

        },
        //使用Flash方式上传
        _UploadFileCore_ByFlash: function ( options )
        {
            //获得当前对象
            var me = this;

            //判定窗体是否创建
            if ( !spms.common.IsValid( me._WinUpload_Flash ) )
            {
                //创建事件处理
                me._Uploader_EventHandlers =
                {
                    //Flash控件加载完毕
                    OnFlashReady: function ()
                    {
                    },
                    //文件被加入队列
                    OnFileQueued: function ( file )
                    {
                        //获得当前对象
                        var me = spms.common;

                        //获得窗体
                        var win = me._WinUpload_Flash;

                        //判断窗体是否有效
                        if ( spms.common.IsValid( win ) )
                        {
                            //启用确定按钮
                            win.down( '#cmdOK' ).enable( true );

                            //设置标题
                            var txtFileName = win.down( '#txtFileName' );

                            //判断控件是否有效
                            if ( spms.common.IsValid( txtFileName ) )
                            {
                                //获得文件名称
                                var fileName = file.name;

                                //设置文件名称
                                txtFileName.setValue( fileName );
                            }
                        }
                    },
                    //文件加入队列错误
                    OnFileQueueError: function ( file, errorCode, message )
                    {
                        try
                        {
                            //根据不同的错误代码做不同的处理
                            switch ( errorCode )
                            {
                                case SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED:
                                    //提示错误信息
                                    Ext.MessageBox.show
                                    (
                                        {
                                            title: spms.resources.text_upload_error_title,
                                            msg: '错误码：' + errorCode + ' (上传队列超过允许的长度) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                            buttons: Ext.Msg.OK,
                                            icon: Ext.Msg.ERROR,
                                            autoScroll: true,
                                            closeAction: 'destroy'
                                        }
                                    );
                                    break;
                                case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
                                    //提示错误信息
                                    Ext.MessageBox.show
                                    (
                                        {
                                            title: spms.resources.text_upload_error_title,
                                            msg: '错误码：' + errorCode + '(上传文件大小超过阈值) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                            buttons: Ext.Msg.OK,
                                            icon: Ext.Msg.ERROR,
                                            autoScroll: true,
                                            closeAction: 'destroy'
                                        }
                                    );
                                    break;
                                case SWFUpload.QUEUE_ERROR.ZERO_BYTE_FILE:
                                    //提示错误信息
                                    Ext.MessageBox.show
                                    (
                                        {
                                            title: spms.resources.text_upload_error_title,
                                            msg: '错误码：' + errorCode + '(IO错误) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                            buttons: Ext.Msg.OK,
                                            icon: Ext.Msg.ERROR,
                                            autoScroll: true,
                                            closeAction: 'destroy'
                                        }
                                    );
                                    break;
                                case SWFUpload.QUEUE_ERROR.INVALID_FILETYPE:
                                    //提示错误信息
                                    Ext.MessageBox.show
                                    (
                                        {
                                            title: spms.resources.text_upload_error_title,
                                            msg: '错误码：' + errorCode + '(IO错误) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                            buttons: Ext.Msg.OK,
                                            icon: Ext.Msg.ERROR,
                                            autoScroll: true,
                                            closeAction: 'destroy'
                                        }
                                    );
                                    break;
                                default:
                                    //提示错误信息
                                    Ext.MessageBox.show
                                    (
                                        {
                                            title: spms.resources.text_upload_error_title,
                                            msg: '错误码：' + errorCode + '(未知错误) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                            buttons: Ext.Msg.OK,
                                            icon: Ext.Msg.ERROR,
                                            autoScroll: true,
                                            closeAction: 'destroy'
                                        }
                                    );
                                    break;
                            }
                        }
                        catch ( ex )
                        {
                            //提示错误信息
                            Ext.MessageBox.show
                            (
                                {
                                    title: spms.resources.text_upload_error_title,
                                    msg: ex,
                                    buttons: Ext.Msg.OK,
                                    icon: Ext.Msg.ERROR
                                }
                            );
                        }
                    },
                    //打开文件对话框
                    OnFileDialogStart: function ()
                    {
                    },
                    //文件对话框关闭
                    OnFileDialogComplete: function ( numFilesSelected, numFilesQueued )
                    {
                        //获得当前对象
                        var me = spms.common;

                        //停止上传
                        me._SWFUploader.stopUpload();
                    },
                    //开始上传
                    OnUploadStart: function ( file )
                    {
                    },
                    //上传进度
                    OnUploadProgress: function ( file, bytesLoaded, bytesTotal )
                    {
                    },
                    //上传成功
                    OnUploadSuccess: function ( file, serverData )
                    {
                        //获得当前对象
                        var me = spms.common;

                        //获得当前窗体
                        var win = spms.common._WinUpload_Flash;

                        //用于保存反馈对象
                        var responseData = {};

                        //解析反馈对象
                        try
                        {
                            //解析反馈数据
                            responseData = Ext.JSON.decode( serverData, false );
                        }
                        catch ( e )
                        {
                            //提示错误信息
                            Ext.MessageBox.show
                            (
                                {
                                    title: spms.resources.text_upload_error_title,
                                    msg: '无法解析文件上传响应。<br/>' + e,
                                    buttons: Ext.Msg.OK,
                                    icon: Ext.Msg.ERROR,
                                    autoScroll: true,
                                    closeAction: 'destroy'
                                }
                            );
                        }

                        //判定是否上传成功
                        if ( responseData.success )
                        {
                            //回调
                            if ( win.options && win.options.callback )
                            {
                                //执行回调
                                win.options.callback( responseData, win.options );
                            }
                        }
                        else
                        {
                            //判定是否没有登录
                            if ( responseData.code == spms.constant.ErrorCodes.Error_Unauthenticated )
                            {
                                //询问
                                Ext.Msg.show
                                (
                                    {
                                        title: spms.resources.text_app_title,
                                        msg: spms.resources.text_msg_login_prompt,
                                        buttons: Ext.Msg.YESNO,
                                        icon: Ext.Msg.QUESTION,
                                        autoScroll: true,
                                        closeAction: 'destroy',
                                        fn: function ( button, text, eOpts )
                                        {
                                            //判断是否确定删除 
                                            if ( button == 'yes' )
                                            {
                                                //如果没有登录，则执行登录
                                                spms.common.Login();
                                            }
                                        }
                                    }
                                );
                            }
                            else
                            {
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_app_title,
                                        msg: responseData.message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                            }
                        }
                    },
                    //上传失败
                    OnUploadError: function ( file, errorCode, message )
                    {
                        //根据不同的错误代码做不同的处理
                        switch ( errorCode )
                        {
                            case SWFUpload.UPLOAD_ERROR.HTTP_ERROR:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(HTTP) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            case SWFUpload.UPLOAD_ERROR.UPLOAD_FAILED:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(上传失败) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            case SWFUpload.UPLOAD_ERROR.IO_ERROR:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(IO错误) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            case SWFUpload.UPLOAD_ERROR.SECURITY_ERROR:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(安全性错误) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            case SWFUpload.UPLOAD_ERROR.UPLOAD_LIMIT_EXCEEDED:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(上传文件大小超过阈值) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            case SWFUpload.UPLOAD_ERROR.FILE_VALIDATION_FAILED:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(验证失败) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(取消上传) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            case SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(停止上传) <br/>文件名称：' + file.name + " <br/>错误信息：" + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                            default:
                                //提示错误信息
                                Ext.MessageBox.show
                                (
                                    {
                                        title: spms.resources.text_upload_error_title,
                                        msg: '错误码：' + errorCode + '(未知错误) <br/>文件名称：' + file.name + " <br/>错误信息： " + message,
                                        buttons: Ext.Msg.OK,
                                        icon: Ext.Msg.ERROR,
                                        autoScroll: true,
                                        closeAction: 'destroy'
                                    }
                                );
                                break;
                        }
                    },
                    //上传完毕
                    OnUploadComplete: function ( file )
                    {
                        //获得当前对象
                        var me = spms.common;

                        //获得当前窗体
                        var win = spms.common._WinUpload_Flash;

                        //隐藏窗体
                        win.hide();
                    },
                    //对象执行完毕
                    OnQueueComplete: function ( numFilesUploaded )
                    {
                    }
                };

                //创建窗体
                me._WinUpload_Flash = new Ext.Window
                (
                    {
                        title: '上传文件',
                        iconCls: 'spms-icon-upload',
                        cls: 'spms-window',
                        closeAction: 'hide',
                        draggable: true,
                        ghost: false,
                        maximizable: false,
                        maximized: false,
                        width: 480,
                        height: 200,
                        autoScroll: false,
                        bodyBorder: false,
                        isTopContainer: true,
                        modal: true,
                        resizable: false,
                        bodyPadding: 0,
                        layout: 'fit',
                        dockedItems:
                        [
                            {
                                xtype: 'toolbar',
                                dock: 'bottom',
                                ui: 'footer',
                                cls: 'spms-window-toolbar',
                                padding: '9 0 9 0',
                                items:
                                [
                                    '->',
                                    {
                                        text: '上传',
                                        disabled: true,
                                        xtype: 'button',
                                        cls: 'spms-window-toolbar-button',
                                        itemId: 'cmdOK',
                                        handler: function ()
                                        {
                                            //当前对象
                                            var me = spms.common;

                                            //获得窗体
                                            var win = me._WinUpload_Flash;

                                            //判断窗体对象是否可用
                                            if ( spms.common.IsValid( win ) )
                                            {
                                                //获得表单对象
                                                var form = win.down( 'form' );

                                                //判断表单是否存在
                                                if ( spms.common.IsValid( form ) )
                                                {
                                                    //显示进度条
                                                    form.setLoading( { msg: spms.resources.text_uploading } );
                                                }

                                                //禁用按钮
                                                win.down( '#cmdOK' ).disable( true );
                                                win.down( '#cmdCancel' ).disable( true );
                                            }

                                            //获得上传参数
                                            var postParams =
                                            {
                                                ASPSESSID: _SessionID,
                                                AUTHID: _AuthenticationID,
                                                OwnerID: options.OwnerID,
                                                FileType: options.FileType
                                            };

                                            //设置上传参数
                                            me._SWFUploader.setPostParams( postParams );

                                            //执行上传
                                            me._SWFUploader.startUpload();
                                        }
                                    },
                                    {
                                        text: '取消',
                                        xtype: 'button',
                                        cls: 'spms-window-toolbar-button',
                                        itemId: 'cmdCancel',
                                        handler: function ()
                                        {
                                            //当前对象
                                            var me = spms.common;

                                            //隐藏窗体
                                            me._WinUpload_Flash.hide();
                                        }
                                    }
                                ]
                            }
                        ],
                        listeners:
                        {
                            hide: function ( win, opts )
                            {
                                //获得表单对象
                                var form = win.down( 'form' );

                                //判定是否存在
                                if ( form )
                                {
                                    //显示进度条
                                    form.setLoading( false );
                                }
                            },
                            show: function ( win, opts )
                            {
                                //获得当前对象
                                var me = spms.common;

                                //禁用确定按钮
                                win.down( '#cmdOK' ).disable( true );
                                //启用取消按钮
                                win.down( '#cmdCancel' ).enable( true );

                                //获得文件类型
                                var file_types = "*.*";
                                var file_types_description = '所有文件（*.*）';
                                var file_size_limit = '0';
                                var upload_url = spms.url.Action( 'UploadTempFile', 'Common' );

                                //设置文件过滤
                                if ( spms.common.IsValid( options.file_types ) )
                                {
                                    file_types = options.file_types;
                                }

                                //判断是否指定了文件类型描述
                                if ( spms.common.IsValid( options.file_types_description ) )
                                {
                                    //设置文件描述
                                    file_types_description = options.file_types_description;
                                }

                                //判断是否设置文件尺寸限制
                                if ( spms.common.IsValid( options.file_size_limit ) )
                                {
                                    //设置文件尺寸限制
                                    file_size_limit = options.file_size_limit;
                                }

                                //判断是否指定了上传路径
                                if ( spms.common.IsValid( options.url ) )
                                {
                                    //设置上传路径
                                    upload_url = options.url;
                                }

                                //判定上传控件是否已经创建
                                if ( !spms.common.IsValid( me._SWFUploader ) )
                                {
                                    //创建设置
                                    var settings =
                                    {
                                        flash_url: '../../Content/SWFUpload/Flash/swfupload.swf',
                                        upload_url: upload_url,
                                        file_size_limit: file_size_limit,
                                        file_types: file_types,
                                        file_types_description: file_types_description,
                                        file_upload_limit: '0',
                                        file_queue_limit: '0',
                                        debug: false,

                                        //按钮设置
                                        button_image_url: '../../Content/Images/bg_button_upload.png',
                                        button_width: '25',
                                        button_height: '25',
                                        button_placeholder_id: 'spms_window_upload_button',
                                        button_text: '',
                                        button_text_left_padding: 0,
                                        button_text_top_padding: 0,

                                        //处理事件
                                        swfupload_loaded_handler: me._Uploader_EventHandlers.OnFlashReady,
                                        file_dialog_start_handler: me._Uploader_EventHandlers.OnFileDialogStart,
                                        file_dialog_complete_handler: me._Uploader_EventHandlers.OnFileDialogComplete,
                                        file_queued_handler: me._Uploader_EventHandlers.OnFileQueued,
                                        file_queue_error_handler: me._Uploader_EventHandlers.OnFileQueueError,
                                        upload_start_handler: me._Uploader_EventHandlers.OnUploadStart,
                                        upload_progress_handler: me._Uploader_EventHandlers.OnUploadProgress,
                                        upload_error_handler: me._Uploader_EventHandlers.OnUploadError,
                                        upload_success_handler: me._Uploader_EventHandlers.OnUploadSuccess,
                                        upload_complete_handler: me._Uploader_EventHandlers.OnUploadComplete,
                                        queue_complete_handler: me._Uploader_EventHandlers.OnQueueComplete
                                    };

                                    //创建上传控件
                                    me._SWFUploader = new SWFUpload( settings );
                                }
                                else
                                {
                                    //设置文件过滤
                                    if ( spms.common.IsValid( options.file_types ) )
                                    {
                                        //判断是否指定了文件类型描述
                                        if ( spms.common.IsValid( options.file_types_description ) )
                                        {
                                            //设置文件描述
                                            me._SWFUploader.setFileTypes( options.file_types, options.file_types_description );
                                        }
                                        else
                                        {
                                            //设置文件描述
                                            me._SWFUploader.setFileTypes( options.file_types, '' );
                                        }
                                    }

                                    //判断是否设置文件尺寸限制
                                    if ( spms.common.IsValid( options.file_size_limit ) )
                                    {
                                        //设置文件尺寸限制
                                        me._SWFUploader.setFileSizeLimit( options.file_size_limit );
                                    }
                                }

                                //判断是否有设置信息
                                if ( options )
                                {
                                    //判断是否指定了标题
                                    if ( options.title )
                                    {
                                        //设置标题
                                        win.setTitle( options.title );
                                    }

                                    //判断是否指定了文件限制提示
                                    if ( options.file_size_limit_tip )
                                    {
                                        //获得文件名
                                        var txtFileName = win.down( '#txtFileName' );

                                        //判断是否有效
                                        if ( txtFileName )
                                        {
                                            //设置文件限制提示
                                            txtFileName.emptyText = options.file_size_limit_tip;
                                            txtFileName.setRawValue( txtFileName.emptyText );
                                        }
                                    }
                                }
                            }
                        },
                        items:
                        [
                            {
                                xtype: 'form',
                                method: 'POST',
                                standardSubmit: false,
                                fileUpload: true,
                                waitTitle: spms.resources.text_app_title,
                                frame: false,
                                waitMsgTarget: true,
                                bodyPadding: 12,
                                bodyCls: 'spms-window-form-body',
                                bodyBorder: false,
                                border: false,
                                defaultType: 'textfield',
                                fieldDefaults:
                                {
                                    labelAlign: 'left',
                                    labelWidth: 72,
                                    anchor: '100%',
                                    msgTarget: 'qtip'
                                },
                                items:
                                [
                                     {
                                         xtype: 'fieldcontainer',
                                         width: '100%',
                                         defaultType: 'textfield',
                                         layout:
                                         {
                                             type: 'hbox',
                                             align: 'stretch'
                                         },
                                         padding: 0,
                                         border: 0,
                                         items:
                                         [
                                            {
                                                xtype: 'textfield',
                                                fieldLabel: '文件名称',
                                                name: 'FileName',
                                                itemId: 'txtFileName',
                                                allowBlank: false,
                                                readOnly: true,
                                                flex: 1
                                            },
                                            {
                                                xtype: 'panel',
                                                margin: '0 0 0 5',
                                                border: 0,
                                                height: 25,
                                                width: 25,
                                                html: '<span id="spms_window_upload_button"></span>'
                                            }
                                         ]
                                     }
                                ]
                            }
                        ]
                    }
                );
            }

            //保存选项
            me._WinUpload_Flash.options = options;
            //居中窗体
            me._WinUpload_Flash.center();
            //显示窗体
            me._WinUpload_Flash.show();
        },
        //使用传统方式上传
        _UploadFileCore: function ( options )
        {
            //获得当前对象
            var me = this;

            //判定窗体是否创建
            if ( !spms.common.IsValid( me._WinUpload ) )
            {
                //创建窗体
                me._WinUpload = new Ext.Window
                (
                    {
                        title: '上传文件',
                        iconCls: 'spms-icon-upload',
                        cls: 'spms-window',
                        closeAction: 'hide',
                        draggable: true,
                        ghost: false,
                        maximizable: false,
                        maximized: false,
                        width: 480,
                        height: 200,
                        autoScroll: false,
                        bodyBorder: false,
                        isTopContainer: true,
                        modal: true,
                        resizable: false,
                        bodyPadding: 0,
                        layout: 'fit',
                        listeners:
                        {
                            hide: function ( win, opts )
                            {
                                //获得表单对象
                                var form = win.down( 'form' );

                                //判定是否存在
                                if ( form )
                                {
                                    //显示进度条
                                    form.setLoading( false );
                                }
                            },
                            show: function ( win, opts )
                            {
                                //禁用确定按钮
                                win.down( '#cmdOK' ).disable( true );
                                //启用取消按钮
                                win.down( '#cmdCancel' ).enable( true );

                                //获得表单对象
                                var form = win.down( 'form' );

                                //判定是否存在
                                if ( form )
                                {
                                    //重置内容
                                    form.getForm().reset();
                                }

                                //判断是否有设置信息
                                if ( options )
                                {
                                    //判断是否指定了标题
                                    if ( options.title )
                                    {
                                        //设置标题
                                        win.setTitle( options.title );
                                    }

                                    //判断是否指定了文件限制提示
                                    if ( options.file_size_limit_tip )
                                    {
                                        //获得文件名
                                        var txtFileName = win.down( '#txtFileName' );

                                        //判断是否有效
                                        if ( txtFileName )
                                        {
                                            //设置文件限制提示
                                            txtFileName.emptyText = options.file_size_limit_tip;
                                            txtFileName.setRawValue( txtFileName.emptyText );
                                        }
                                    }
                                }
                            }
                        },
                        items:
                        [
                            {
                                xtype: 'form',
                                method: 'POST',
                                standardSubmit: false,
                                fileUpload: true,
                                waitTitle: spms.resources.text_app_title,
                                frame: false,
                                waitMsgTarget: true,
                                bodyPadding: 12,
                                bodyCls: 'spms-window-form-body',
                                bodyBorder: false,
                                border: false,
                                defaultType: 'textfield',
                                fieldDefaults:
                                {
                                    labelAlign: 'left',
                                    labelWidth: 72,
                                    anchor: '100%',
                                    msgTarget: 'qtip'
                                },
                                items:
                                [
                                    {
                                        xtype: 'filefield',
                                        name: 'FileName',
                                        itemId: 'txtFileName',
                                        fieldLabel: '文件名称',
                                        allowBlank: false,
                                        buttonText: '',
                                        buttonConfig:
                                        {
                                            width: 25,
                                            height: 25,
                                            margin: '0 0 0 5',
                                            iconCls: 'spms-icon-upload'
                                        },
                                        listeners:
                                        {
                                            //处理变更事件
                                            change: function ( sender, value, eOpts )
                                            {
                                                //获得当前对象
                                                var me = spms.common;

                                                //获得窗体
                                                var win = me._WinUpload;

                                                //判断窗体是否有效
                                                if ( spms.common.IsValid( win ) )
                                                {
                                                    //启用确定按钮
                                                    win.down( '#cmdOK' ).enable( true );
                                                }
                                            }
                                        }
                                    }
                                ]
                            }
                        ],
                        dockedItems:
                        [
                            {
                                xtype: 'toolbar',
                                dock: 'bottom',
                                ui: 'footer',
                                cls: 'spms-window-toolbar',
                                padding: '9 0 9 0',
                                items:
                                [
                                    '->'
                                    ,
                                    {
                                        text: '上传',
                                        xtype: 'button',
                                        cls: 'spms-window-toolbar-button',
                                        itemId: 'cmdOK',
                                        handler: function ()
                                        {
                                            //当前对象
                                            var me = spms.common;

                                            //获得窗体
                                            var win = me._WinUpload;

                                            //判断窗体对象是否可用
                                            if ( !spms.common.IsValid( win ) )
                                            {
                                                //直接返回
                                                return;
                                            }

                                            //获得表单对象
                                            var form = win.down( 'form' );

                                            //判断表单是否存在
                                            if ( !spms.common.IsValid( form ) )
                                            {
                                                //直接返回
                                                return;
                                            }

                                            //用于保存上传路径
                                            var upload_url = spms.url.Action( 'UploadTempFile', 'Common' );

                                            //判断是否指定了上传路径
                                            if ( spms.common.IsValid( options.url ) )
                                            {
                                                //设置上传路径
                                                upload_url = options.url;
                                            }

                                            //获得表单对象
                                            var formBase = form.getForm();

                                            //检查数据是否合法
                                            if ( formBase.isValid() )
                                            {
                                                //提交数据
                                                formBase.submit
                                                (
                                                    {
                                                        url: upload_url,
                                                        method: spms.constant.HttpMethod.Post,
                                                        submitEmptyText: false,
                                                        waitTitle: spms.resources.text_submitting_title,
                                                        waitMsg: spms.resources.text_submitting,
                                                        success: function ( form, action )
                                                        {
                                                            //获得处理结果
                                                            var response = spms.exception.HandleSuccessError( form, action );

                                                            //处理提交错误
                                                            if ( spms.common.IsValid( response ) )
                                                            {
                                                                //回调
                                                                if ( win.options && win.options.callback )
                                                                {
                                                                    //执行回调
                                                                    win.options.callback( responseData, win.options );
                                                                }
                                                            }

                                                            //隐藏窗体
                                                            win.hide();
                                                        },
                                                        failure: function ( form, action )
                                                        {
                                                            //隐藏窗体
                                                            win.hide();

                                                            //处理异常
                                                            spms.exception.HandleFailureError( form, action );
                                                        }
                                                    }
                                                );
                                            }
                                        }
                                    },
                                    {
                                        text: '取消',
                                        xtype: 'button',
                                        cls: 'spms-window-toolbar-button',
                                        itemId: 'cmdCancel',
                                        handler: function ()
                                        {
                                            //当前对象
                                            var me = spms.common;

                                            //获得窗体
                                            var win = me._WinUpload;

                                            //隐藏窗体
                                            win.hide();
                                        }
                                    }
                                ]
                            }
                        ]
                    }
                );
            }

            //保存选项
            me._WinUpload.options = options;
            //居中窗体
            me._WinUpload.center();
            //显示窗体
            me._WinUpload.show();
        }
    };

    //添加导航类
    _spms.navigation =
    {
        //页面缓存
        _pages: new Array(),

        //导航面板
        _panel: undefined,

        //获得导航面板
        _GetNavigationPanel: function ()
        {
            //判断导航面板是否已经初始化
            if ( !spms.navigation._panel )
            {
                //获得导航面板
                spms.navigation._panel = Ext.getCmp( 'spms-tabpanel-pagecontainer' );
            }

            //返回导航面板
            return spms.navigation._panel;
        },
        //导航
        Navigate: function ( options )
        {
            //获得导航面板
            var nav_panel = spms.navigation._GetNavigationPanel();

            //获得主机地址
            var hostUrl = spms.url.GetHostUrl();

            //判断导航面板是否已经初始化
            if ( nav_panel )
            {
                //循环检索指定的面板是否已经打开
                for ( var index = 0; index < nav_panel.items.length; index++ )
                {
                    //获得面板
                    var tempPanel = nav_panel.items.getAt( index );

                    //判断是否附加了参数
                    if ( tempPanel.nav_options )
                    {
                        //判断指定的页面是否已经打开
                        if ( tempPanel.nav_options.id == options.id )
                        {
                            //打开指定的面板
                            tempPanel.show();

                            //返回
                            return;
                        }
                    }
                }

                //拼接页面地址
                var pageUrl = hostUrl.concat( options.url, '?title=', options.title );

                //添加面板
                var panel = nav_panel.add
                    (
                        {
                            xtype: 'panel',
                            closable: true,
                            html: '<iframe src='.concat( '\'', pageUrl, '\' class=\'spms-page-frame\'></iframe>' ),
                            iconCls: options.iconCls,
                            title: options.title,
                            closeText: '关闭' + options.title
                        }
                    );

                //附加信息
                panel.nav_options = options;

                //显示面板
                panel.show();
            }
        },
        //刷新当前标签页
        Refresh: function ()
        {
            //获得导航面板
            var panel = spms.navigation._GetNavigationPanel();

            //判断导航面板是否已经初始化
            if ( panel )
            {
                //获得当前活动标签
                var currentTab = panel.getActiveTab();

                //判断是否有活动标签
                if ( currentTab )
                {
                    //获得IFrame元素
                    var frames = Ext.query( 'iframe[class=spms-page-frame]', Ext.getDom( currentTab.getEl() ), 'select', true );

                    //判断是否检索到元素
                    if ( frames.length > 0 && frames[0] )
                    {
                        //刷新页面
                        frames[0].src = frames[0].src;
                    }
                }
            }
        },
        //回到首页
        GoHome: function ()
        {
            //获得导航面板
            var panel = spms.navigation._GetNavigationPanel();

            //判断导航面板是否已经初始化
            if ( panel )
            {
                //激活第一个标签页
                panel.setActiveTab( 0 );
            }
        }
    };

    //添加事件处理类
    _spms.event =
    {
        //菜单数据存储对象
        _MenuStore: undefined,

        //处理当前角色变化事件
        OnCurrentRoleChanged: function ( select )
        {
            //判断菜单数据存储对象是否已经加载
            if ( !spms.event._MenuStore )
            {
                //获得组件
                var menu = Ext.getCmp( 'spms-panel-menu' );

                //判断是否存在
                if ( menu )
                {
                    //获得数据存储对象
                    spms.event._MenuStore = menu.getStore();
                }
            }

            //判断数据存储对象是否存在
            if ( spms.event._MenuStore )
            {
                //清除数据过滤
                spms.event._MenuStore.filters.clear( true );

                //过滤数据
                spms.event._MenuStore.reload( { filters: [{ property: 'Role_Name@E', value: select.value }] } );
            }
        },
        //处理菜单点击事件
        OnMenuClick: function ( panel, record, item, index, e, eOpts )
        {
            //创建导航参数
            var options =
                {
                    url: record.get( 'url' ),
                    title: record.get( 'text' ),
                    iconCls: record.get( 'iconCls' ),
                    id: record.get( 'pageID' )
                };

            //判断是否指定了导航地址 
            if ( options.url )
            {
                //执行导航
                spms.navigation.Navigate( options );
            }
        },
        //处理菜单栏显示或者隐藏
        OnMenuBarButtonClick: function ( sender )
        {
            //获得当前范围
            var me = this;

            //判断面板是否已经初始化
            if ( !me._panel_menu )
            {
                //获得菜单栏
                me._panel_menu = Ext.getCmp( 'spms-panel-menu' );
            }

            //判断面板是否已经初始化
            if ( me._panel_menu )
            {
                //设置可见状态
                me._panel_menu.setVisible( !me._panel_menu.isVisible() );
            }
        },
        //处理消息栏显示或者隐藏
        OnMessageBarButtonClick: function ( sender )
        {
            //获得当前范围
            var me = this;

            //判断面板是否已经初始化
            if ( !me._panel_message )
            {
                //获得菜单栏
                me._panel_message = Ext.getCmp( 'spms-panel-message' );
            }

            //判断面板是否已经初始化
            if ( me._panel_message )
            {
                //设置可见状态
                me._panel_message.setVisible( !me._panel_message.isVisible() );
            }
        },
        //处理复选框标签选中状态变化事件
        OnCheckBoxLabelChange: function ( checkbox, newValue, oldValue, options )
        {
            //获得控件的编号
            var itemId = checkbox.getItemId();

            //去掉前缀
            var targetId = itemId.substring( 3 );

            //检索指定的控件是否存在
            var target = checkbox.up( 'form' ).down( '#'.concat( targetId ) );

            //判断控件是否存在
            if ( target && newValue )
            {
                //设置焦点
                target.focus();
            }
        },
        //处理图片预览事件
        OnPreviewImage: function ( sender )
        {
            //获得图片对象
            var image = $( sender );

            //判断对象是否有效
            if ( !spms.common.IsValid( image ) )
            {
                //直接返回
                return;
            }

            //获得属性
            var dataUrl = image.attr( 'data-url' );
            var dataTitle = image.attr( 'data-title' );
            var dataDesc = image.attr( 'data-desc' );
            var dataTarget = image.attr( 'data-target' );

            //设置属性
            $( 'span#span_'.concat( dataTarget ) ).text( dataTitle );
            $( 'img#img_'.concat( dataTarget ) ).attr( 'src', dataUrl );
        },
        //处理前移
        OnThumbnailsBackward: function ( target )
        {
            //获得对象
            var panel = $( 'div#'.concat( target ) );

            //判断是否存在元素
            if ( panel.length > 0 )
            {
                //判断是否可以移动
                if ( panel[0].scrollWidth - panel.width() > 0 )
                {
                    //卷动
                    panel.animate( { scrollLeft: panel[0].scrollLeft + 70 } );
                }
            }
        },
        //处理后移
        OnThumbnailsForward: function ( target )
        {
            //获得对象
            var panel = $( 'div#'.concat( target ) );

            //判断是否存在元素
            if ( panel.length > 0 )
            {
                //判断是否可以移动
                if ( panel[0].scrollLeft > 0 )
                {
                    //卷动
                    panel.animate( { scrollLeft: panel[0].scrollLeft - 70 } );
                }
            }
        },
        //处理可复选树加载完毕事件
        OnCheckableTreeLoad: function ( store, node, records, successful, eOpts )
        {
            //获得树
            var tree = node.getOwnerTree();

            //用于保存父节点
            var parentNodes = [];

            //获得选中的节点
            var checkedNodes = tree.getChecked();

            //循环处理节点
            for ( var index = 0; index < checkedNodes.length; index++ )
            {
                //获得当前节点
                var currentNode = checkedNodes[index];

                //获得父节点
                var parent = currentNode.parentNode;

                //判断节点是否有效
                if ( spms.common.IsValid( parent ) )
                {
                    //判断是否已经处理过
                    if ( parentNodes.indexOf( parent ) == -1 )
                    {
                        //处理节点
                        spms.event.OnTreeNodeCheckChange.call( tree, currentNode, true, eOpts );
                    }

                    //添加到数组
                    parentNodes.push( parent );
                }
            }
        },
        //处理树节点选中变化事件
        OnTreeNodeCheckChange: function ( node, checked, eOpts )
        {
            //获得父节点
            var parent = node.parentNode;

            //用于保存是否有子节点已经选中
            var someChecked = false;

            //判断是否存在父节点
            while ( spms.common.IsValid( parent ) )
            {
                //用于保存是否全部选中
                var checkedAll = true;

                //用于保存节点是否选中
                var isChecked = false;

                //判断所有的子节点是否都已经被选中
                parent.eachChild
                (
                    function ( node )
                    {
                        //获得节点的选中状态
                        isChecked = node.get( 'checked' );

                        //设置部分选中状态
                        if ( isChecked )
                        {
                            //设置为部分选中
                            someChecked = true;
                        }

                        //设置全选状态
                        checkedAll = isChecked & checkedAll;
                    }
                );

                //获得行元素
                var rowElement = $( spms.common.GetTreeNodeHtmlElement( parent ) );

                //判断是否全部选中
                if ( checkedAll )
                {
                    //取消三态
                    rowElement.toggleClass( 'spms-checkbox-indeterminate', false );

                    //选中父节点
                    parent.set( 'checked', true );
                }
                else if ( someChecked )
                {
                    //取消选中
                    parent.set( 'checked', false );

                    //设置三态
                    rowElement.toggleClass( 'spms-checkbox-indeterminate', true );
                }
                else
                {
                    //设置三态
                    rowElement.toggleClass( 'spms-checkbox-indeterminate', false );

                    //选中父节点
                    parent.set( 'checked', false );
                }

                //获得父节点
                parent = parent.parentNode;
            }

            //处理所有的子节点
            node.cascadeBy
            (
                function ( node )
                {
                    node.set( 'checked', checked );
                }
            );
        },
        //获得行表单展开事件处理器
        GetRowExpandEventHandler: function ( options )
        {
            //返回函数
            return function ( rowNode, record, expandRow, eOpts )
            {
                //用于保存是否加载数据
                var isLoadContent = false;

                //判断面板是否已经创建
                if ( !spms.common.IsValid( expandRow._panel_body ) )
                {
                    //设置加载内容
                    isLoadContent = true;

                    //用于保存高度
                    var height = 200;

                    //判断是否指定了高度
                    if ( spms.common.IsValid( options.height ) )
                    {
                        //设置高度
                        height = options.height;
                    }

                    //获得当前记录编号
                    var recordID = record.getId();

                    //创建面板
                    expandRow._panel_body = Ext.create
                    (
                        'Ext.panel.Panel',
                        {
                            border: false,
                            layout: 'fit',
                            autoScroll: true,
                            height: height,
                            renderTo: recordID,
                            padding: 0
                        }
                    );
                }

                //获得当前面板
                var panel = expandRow._panel_body;

                //判断是否需要加载内容
                if ( !isLoadContent && options.isForceReload )
                {
                    //设置需要加载内容
                    isLoadContent = true;
                }

                //加载内容
                if ( isLoadContent )
                {
                    //用于保存加载进度显示位置
                    var maskTarget = panel;

                    //判断是否指定加载进度显示位置
                    if ( spms.common.IsValid( options.maskTarget ) )
                    {
                        //设置进度显示位置
                        maskTarget = options.maskTarget;
                    }

                    //显示加载进度条
                    maskTarget.setLoading( spms.resources.text_loading );

                    //用于保存参数
                    var params = record.getData();

                    //判断是否指定了参数
                    if ( spms.common.IsValid( options.params ) )
                    {
                        params = options.params;
                    }

                    //创建请求对象
                    Ext.Ajax.request
                    (
                        {
                            url: options.url,
                            method: spms.constant.HttpMethod.POST,
                            jsonData: params,
                            callback: function ( ajaxOptions, success, response )
                            {
                                //显示内容
                                panel.update( response.responseText );
                                //隐藏加载进度
                                maskTarget.setLoading( false );
                            }
                        }
                    );
                }
            }
        },
        //获得行表单收缩事件处理器
        GetRowCollapseEventHandler: function ( options )
        {
            //返回函数
            return function ( rowNode, record, expandRow, eOpts )
            {
                //获得当前面板
                var panel = expandRow._panel_body;

                //判断面板是否已经初始化
                if ( !spms.common.IsValid( panel ) )
                {
                    //直接返回
                    return;
                }

                //用于保存加载进度显示位置
                var maskTarget = panel;

                //判断是否指定加载进度显示位置
                if ( spms.common.IsValid( options.maskTarget ) )
                {
                    //设置进度显示位置
                    maskTarget = options.maskTarget;
                }

                //判断是否总是重新加载
                if ( options.isForceReload )
                {
                    //更新内容
                    panel.update( null );
                }

                //隐藏加载进度
                maskTarget.setLoading( false );
            }
        }
    };

    //添加URL操作辅助类
    _spms.url =
    {
        //主机地址
        _HostUrl: undefined,

        //生成绝对地址
        Action: function ( actionName, controllerName, parameters )
        {
            //生成导航地址
            var url = _ApplicationPath;

            //生成导航地址
            url = url.concat( controllerName, '/', actionName );

            //判断是否有参数
            if ( parameters )
            {
                //判断是否为数组
                if ( jQuery.isArray( parameters ) )
                {
                    //用于保存参数
                    var queryString = '';

                    //用于保存参数
                    var param = null;

                    //循环添加参数
                    for ( var index = 0; index < parameters.length; index++ )
                    {
                        //循环添加参数
                        param = parameters[index];

                        //判断是否指定了名称
                        if ( spms.common.IsValid( param.Name ) && spms.common.IsValid( param.Value ) )
                        {
                            //判断是否需要添加&
                            if ( queryString.length > 0 )
                            {
                                queryString = queryString.concat( '&' );
                            }

                            //添加参数
                            queryString = queryString.concat( encodeURI( param.Name.toString() ) );
                            queryString = queryString.concat( '=' );
                            queryString = queryString.concat( encodeURI( param.Value.toString() ) );
                        }
                    }

                    //添加参数
                    if ( queryString.length > 0 )
                    {
                        url = url.concat( '?', queryString );
                    }
                }
                else
                {
                    //添加参数
                    url = url.concat( '?', parameters );
                }
            }

            //返回导航地址
            return url;
        },
        //获得主机地址
        GetHostUrl: function ()
        {
            //判断主机地址是否已经初始化
            if ( !spms.url._HostUrl )
            {
                //获得主机地址
                var host = window.location.protocol.concat( '//', window.location.hostname );

                //判断是否为80端口
                if ( window.location.port != 80 )
                {
                    //附加端口号
                    host = host.concat( ':', window.location.port );
                }

                //附加应用程序路径
                host = host.concat( _ApplicationPath );

                //保存主机地址
                spms.url._HostUrl = host;
            }

            //返回地址
            return spms.url._HostUrl;
        },
        //拼接地址
        Concat: function ( url1, url2 )
        {


        }
    };

    //添加异常处理类
    _spms.exception =
    {
        //处理未捕获的错误
        HandleUnhandleedError: function ( msg, url, line )
        {
            //创建错误消息
            var message = spms.resources.text_unhandled_javascript_error;

            //添加错误提示
            message = message.concat( '<br/><br/>错误信息：', msg, "<br/>文件：", url, "<br/>行号：", line );

            //提示错误信息
            Ext.MessageBox.show
            (
                {
                    title: spms.resources.text_javascript_error_title,
                    msg: message,
                    buttons: Ext.MessageBox.OK,
                    icon: Ext.Msg.ERROR,
                    autoScroll: true,
                    closeAction: 'destroy'
                }
            );
        },
        //处理代理异常
        HandleProxyError: function ( proxy, response, operation, eOpts )
        {
            //处理HTTP响应错误
            var responseData = spms.exception.HandleResponseError( response );

            //判断是否成功
            if ( spms.common.IsValid( responseData ) && responseData.success )
            {
                //返回处理成功
                return true;
            }
            else
            {
                //返回处理失败
                return false;
            }
        },
        //处理Ajax请求异常
        HandleAjaxRequestError: function ( options, success, response )
        {
            //判定是否发生错误
            if ( !success && spms.common.IsValid( options ) && options.failure )
            {
                //判断是否设置了回调方法
                if ( jQuery.isFunction( options.failure ) )
                {
                    //直接调用失败回调方法
                    options.failure( response, options );
                }

                //返回失败
                return false;
            }

            //处理HTTP响应错误
            var responseData = spms.exception.HandleResponseError( response );

            //判断是否成功
            if ( spms.common.IsValid( responseData ) && responseData.success )
            {
                //返回处理成功
                return true;
            }
            else
            {
                //返回处理失败
                return false;
            }
        },
        //处理窗体提交异常
        HandleSuccessError: function ( form, action )
        {
            //处理HTTP响应错误
            var responseData = spms.exception.HandleResponseError( action.response );

            //判断是否成功
            if ( spms.common.IsValid( responseData ) && responseData.success )
            {
                //返回处理成功
                return true;
            }
            else
            {
                //返回处理失败
                return false;
            }
        },
        HandleFailureError: function ( form, action )
        {
            var responseData = spms.exception.HandleResponseError( action.response, action.failureType );

            //判断是否成功
            if ( spms.common.IsValid( responseData ) && responseData.success )
            {
                //返回处理成功
                return true;
            }
            else
            {
                //返回处理失败
                return false;
            }
        },
        //处理HTTP响应错误
        HandleResponseError: function ( response, failureType )
        {
            //用于保存反馈对象
            var responseData = {};

            //解析反馈对象
            try
            {
                //解析反馈数据
                responseData = Ext.JSON.decode( response.responseText, false );

                //判断是否解析成功
                if ( !spms.common.IsValid( responseData ) )
                {
                    //抛出异常
                    throw response.responseText;
                }
            }
            catch ( error )
            {
                //用于保存错误信息
                var msg = spms.resources.text_error_unhandleable_response + '<br/><br/>反馈内容:' + response.responseText + '<br/>错误信息:' + error;

                //用于保存错误信息 
                var message = spms.resources.text_error_server_failure;

                //判断是否指定了失败类型
                if ( spms.common.IsValid( failureType ) )
                {
                    //根据错误类型的不同分别处理
                    switch ( failureType )
                    {
                        //判定是否为数据无效                                                                                                                                                                                                                                               
                        case Ext.form.action.Action.CLIENT_INVALID:
                            //设置错误信息
                            message = spms.resources.text_error_client_invalid;
                            break;
                        case Ext.form.action.Action.CONNECT_FAILURE:
                            //设置错误信息
                            message = spms.resources.text_error_connect_failure;
                            break;
                        case Ext.form.action.Action.LOAD_FAILURE:
                            //设置错误信息
                            message = spms.resources.text_error_load_failure;
                            break;
                        case Ext.form.action.Action.SERVER_INVALID:
                            //判断是否指定了错误信息
                            if ( action.result && action.result.message )
                            {
                                //使用指定的错误信息
                                message = action.result.message;
                            }
                            else
                            {
                                //使用默认提示信息
                                message = spms.resources.text_error_server_failure;
                            }
                            break;
                        default:
                            //默认错误信息
                            message = spms.resources.text_error_unknown;
                            break;
                    }
                }

                //用于保存反馈内容
                var responseText = response.responseText;

                //判断是否有反馈内容
                if ( spms.common.IsNullOrEmpty( responseText ) )
                {
                    //设置内容
                    responseText = '';
                }

                //判断是否有错误信息
                if ( spms.common.IsNullOrEmpty( error ) )
                {
                    //设置错误信息
                    error = failureType;
                }

                //用于保存错误信息
                var msg = spms.resources.text_error_unhandleable_response + '<br/><br/>反馈内容:' + responseText + '<br/>错误信息:' + error + '<br/>错误描述:' + message;

                //提示错误信息
                Ext.MessageBox.show
                (
                    {
                        title: spms.resources.text_app_title,
                        msg: msg,
                        buttons: Ext.Msg.OK,
                        icon: Ext.Msg.ERROR,
                        autoScroll: true,
                        closeAction: 'destroy'
                    }
                );

                //返回
                return responseData;
            }

            //判定是否称成功
            if ( responseData.success )
            {
                //如果成功，则直接返回
                return responseData;
            }

            //判定是否没有登录
            if ( responseData.code == spms.constant.ErrorCodes.Error_Unauthenticated )
            {
                //询问
                Ext.Msg.show
                (
                    {
                        title: spms.resources.text_app_title,
                        msg: spms.resources.text_msg_login_prompt,
                        buttons: Ext.Msg.YESNO,
                        icon: Ext.Msg.QUESTION,
                        autoScroll: true,
                        closeAction: 'destroy',
                        fn: function ( button, text, eOpts )
                        {
                            //判断是否确定删除 
                            if ( button == 'yes' )
                            {
                                //如果没有登录，则执行登录
                                spms.common.Login();
                            }
                        }
                    }
                );
            }
            else
            {
                //提示错误信息
                Ext.MessageBox.show
                (
                    {
                        title: spms.resources.text_app_title,
                        msg: responseData.message,
                        buttons: Ext.Msg.OK,
                        icon: Ext.Msg.ERROR,
                        autoScroll: true,
                        closeAction: 'destroy'
                    }
                );
            }

            //默认返回失败
            return responseData;
        }
    };

    //添加格式化处理类
    _spms.format =
    {
        //渲染布尔数据
        booleanRenderer: function ( value )
        {
            try
            {
                //判断是否选中
                if ( value )
                {
                    return '<img src=\'\' class=\'x-grid-checkcolumn x-grid-checkcolumn-checked spms-grid-checkbox\'/>';
                }
                else
                {
                    return '<img src=\'\' class=\'x-grid-checkcolumn spms-grid-checkbox\'/>';
                }
            }
            catch ( ex )
            {
                return value;
            }
        },
        gridButtonsRenderer: function (value)
        {
            try {
                if (value) {
                    return '<input type=\'button\' class=\'spms-icon-upload\' id=\'btn' + value + '\'/>';
                }
                else {
                    return '<input type=\'button\' class=\'spms-icon-upload\' />';
                }
                
            }
            catch (ex) {
                return value;
            }
        }
    };

    //将对象绑定到全局对象
    window.spms = spms;
}
)();
